/*
 * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.servlet.support;

import java.beans.PropertyEditor;
import java.util.Arrays;
import java.util.List;

import org.springframework.beans.BeanWrapper;
import org.springframework.beans.PropertyAccessorFactory;
import org.springframework.context.NoSuchMessageException;
import org.springframework.lang.Nullable;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import org.springframework.validation.BindingResult;
import org.springframework.validation.Errors;
import org.springframework.validation.ObjectError;
import org.springframework.web.util.HtmlUtils;

/**
 * Simple adapter to expose the bind status of a field or object.
 * Set as a variable both by the JSP bind tag and FreeMarker macros.
 *
 * <p>Obviously, object status representations (i.e. errors at the object level
 * rather than the field level) do not have an expression and a value but only
 * error codes and messages. For simplicity's sake and to be able to use the same
 * tags and macros, the same status class is used for both scenarios.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @author Darren Davison
 * @see RequestContext#getBindStatus
 * @see org.springframework.web.servlet.tags.BindTag
 * @see org.springframework.web.servlet.view.AbstractTemplateView#setExposeSpringMacroHelpers
 */
public class BindStatus {

    private final RequestContext requestContext;

    private final String path;

    private final boolean htmlEscape;

    @Nullable
    private final String expression;

    @Nullable
    private final Errors errors;

    private final String[] errorCodes;

    @Nullable
    private String[] errorMessages;

    @Nullable
    private List<? extends ObjectError> objectErrors;

    @Nullable
    private Object value;

    @Nullable
    private Class<?> valueType;

    @Nullable
    private Object actualValue;

    @Nullable
    private PropertyEditor editor;

    @Nullable
    private BindingResult bindingResult;


    /**
     * Create a new BindStatus instance, representing a field or object status.
     *
     * @param requestContext the current RequestContext
     * @param path the bean and property path for which values and errors
     * will be resolved (e.g. "customer.address.street")
     * @param htmlEscape whether to HTML-escape error messages and string values
     * @throws IllegalStateException if no corresponding Errors object found
     */
    public BindStatus(RequestContext requestContext, String path, boolean htmlEscape) throws IllegalStateException {
        this.requestContext = requestContext;
        this.path = path;
        this.htmlEscape = htmlEscape;

        // determine name of the object and property
        String beanName;
        int dotPos = path.indexOf('.');
        if (dotPos == -1) {
            // property not set, only the object itself
            beanName = path;
            this.expression = null;
        } else {
            beanName = path.substring(0, dotPos);
            this.expression = path.substring(dotPos + 1);
        }

        this.errors = requestContext.getErrors(beanName, false);

        if (this.errors != null) {
            // Usual case: A BindingResult is available as request attribute.
            // Can determine error codes and messages for the given expression.
            // Can use a custom PropertyEditor, as registered by a form controller.
            if (this.expression != null) {
                if ("*".equals(this.expression)) {
                    this.objectErrors = this.errors.getAllErrors();
                } else if (this.expression.endsWith("*")) {
                    this.objectErrors = this.errors.getFieldErrors(this.expression);
                } else {
                    this.objectErrors = this.errors.getFieldErrors(this.expression);
                    this.value = this.errors.getFieldValue(this.expression);
                    this.valueType = this.errors.getFieldType(this.expression);
                    if (this.errors instanceof BindingResult) {
                        this.bindingResult = (BindingResult) this.errors;
                        this.actualValue = this.bindingResult.getRawFieldValue(this.expression);
                        this.editor = this.bindingResult.findEditor(this.expression, null);
                    } else {
                        this.actualValue = this.value;
                    }
                }
            } else {
                this.objectErrors = this.errors.getGlobalErrors();
            }
            this.errorCodes = initErrorCodes(this.objectErrors);
        } else {
            // No BindingResult available as request attribute:
            // Probably forwarded directly to a form view.
            // Let's do the best we can: extract a plain target if appropriate.
            Object target = requestContext.getModelObject(beanName);
            if (target == null) {
                throw new IllegalStateException("Neither BindingResult nor plain target object for bean name '" +
                        beanName + "' available as request attribute");
            }
            if (this.expression != null && !"*".equals(this.expression) && !this.expression.endsWith("*")) {
                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(target);
                this.value = bw.getPropertyValue(this.expression);
                this.valueType = bw.getPropertyType(this.expression);
                this.actualValue = this.value;
            }
            this.errorCodes = new String[0];
            this.errorMessages = new String[0];
        }

        if (htmlEscape && this.value instanceof String) {
            this.value = HtmlUtils.htmlEscape((String) this.value);
        }
    }

    /**
     * Extract the error codes from the ObjectError list.
     */
    private static String[] initErrorCodes(List<? extends ObjectError> objectErrors) {
        String[] errorCodes = new String[objectErrors.size()];
        for (int i = 0; i < objectErrors.size(); i++) {
            ObjectError error = objectErrors.get(i);
            errorCodes[i] = error.getCode();
        }
        return errorCodes;
    }


    /**
     * Return the bean and property path for which values and errors
     * will be resolved (e.g. "customer.address.street").
     */
    public String getPath() {
        return this.path;
    }

    /**
     * Return a bind expression that can be used in HTML forms as input name
     * for the respective field, or {@code null} if not field-specific.
     * <p>Returns a bind path appropriate for resubmission, e.g. "address.street".
     * Note that the complete bind path as required by the bind tag is
     * "customer.address.street", if bound to a "customer" bean.
     */
    @Nullable
    public String getExpression() {
        return this.expression;
    }

    /**
     * Return the current value of the field, i.e. either the property value
     * or a rejected update, or {@code null} if not field-specific.
     * <p>This value will be an HTML-escaped String if the original value
     * already was a String.
     */
    @Nullable
    public Object getValue() {
        return this.value;
    }

    /**
     * Get the '{@code Class}' type of the field. Favor this instead of
     * '{@code getValue().getClass()}' since '{@code getValue()}' may
     * return '{@code null}'.
     */
    @Nullable
    public Class<?> getValueType() {
        return this.valueType;
    }

    /**
     * Return the actual value of the field, i.e. the raw property value,
     * or {@code null} if not available.
     */
    @Nullable
    public Object getActualValue() {
        return this.actualValue;
    }

    /**
     * Return a suitable display value for the field, i.e. the stringified
     * value if not null, and an empty string in case of a null value.
     * <p>This value will be an HTML-escaped String if the original value
     * was non-null: the {@code toString} result of the original value
     * will get HTML-escaped.
     */
    public String getDisplayValue() {
        if (this.value instanceof String) {
            return (String) this.value;
        }
        if (this.value != null) {
            return (this.htmlEscape ? HtmlUtils.htmlEscape(this.value.toString()) : this.value.toString());
        }
        return "";
    }

    /**
     * Return if this status represents a field or object error.
     */
    public boolean isError() {
        return (this.errorCodes.length > 0);
    }

    /**
     * Return the error codes for the field or object, if any.
     * Returns an empty array instead of null if none.
     */
    public String[] getErrorCodes() {
        return this.errorCodes;
    }

    /**
     * Return the first error codes for the field or object, if any.
     */
    public String getErrorCode() {
        return (this.errorCodes.length > 0 ? this.errorCodes[0] : "");
    }

    /**
     * Return the resolved error messages for the field or object,
     * if any. Returns an empty array instead of null if none.
     */
    public String[] getErrorMessages() {
        return initErrorMessages();
    }

    /**
     * Return the first error message for the field or object, if any.
     */
    public String getErrorMessage() {
        String[] errorMessages = initErrorMessages();
        return (errorMessages.length > 0 ? errorMessages[0] : "");
    }

    /**
     * Return an error message string, concatenating all messages
     * separated by the given delimiter.
     *
     * @param delimiter separator string, e.g. ", " or "<br>"
     * @return the error message string
     */
    public String getErrorMessagesAsString(String delimiter) {
        return StringUtils.arrayToDelimitedString(initErrorMessages(), delimiter);
    }

    /**
     * Extract the error messages from the ObjectError list.
     */
    private String[] initErrorMessages() throws NoSuchMessageException {
        if (this.errorMessages == null) {
            if (this.objectErrors != null) {
                this.errorMessages = new String[this.objectErrors.size()];
                for (int i = 0; i < this.objectErrors.size(); i++) {
                    ObjectError error = this.objectErrors.get(i);
                    this.errorMessages[i] = this.requestContext.getMessage(error, this.htmlEscape);
                }
            } else {
                this.errorMessages = new String[0];
            }
        }
        return this.errorMessages;
    }

    /**
     * Return the Errors instance (typically a BindingResult) that this
     * bind status is currently associated with.
     *
     * @return the current Errors instance, or {@code null} if none
     * @see org.springframework.validation.BindingResult
     */
    @Nullable
    public Errors getErrors() {
        return this.errors;
    }

    /**
     * Return the PropertyEditor for the property that this bind status
     * is currently bound to.
     *
     * @return the current PropertyEditor, or {@code null} if none
     */
    @Nullable
    public PropertyEditor getEditor() {
        return this.editor;
    }

    /**
     * Find a PropertyEditor for the given value class, associated with
     * the property that this bound status is currently bound to.
     *
     * @param valueClass the value class that an editor is needed for
     * @return the associated PropertyEditor, or {@code null} if none
     */
    @Nullable
    public PropertyEditor findEditor(Class<?> valueClass) {
        return (this.bindingResult != null ? this.bindingResult.findEditor(this.expression, valueClass) : null);
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("BindStatus: ");
        sb.append("expression=[").append(this.expression).append("]; ");
        sb.append("value=[").append(this.value).append("]");
        if (!ObjectUtils.isEmpty(this.errorCodes)) {
            sb.append("; errorCodes=").append(Arrays.asList(this.errorCodes));
        }
        return sb.toString();
    }

}
